home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / TextCmd.C < prev    next >
C/C++ Source or Header  |  1990-12-04  |  11KB  |  447 lines
  1. //$QuickPasteSelector,TextCommand,CutCopyCommand,ChangeStyleCommand,ExtendRangeSelector$
  2. //$PasteCommand,TypeingCommand,CopyDragPasteSelector,RangeSelector$
  3.  
  4. #include "TextView.h" 
  5. #include "TextCmd.h"
  6. #include "CmdNo.h"
  7.  
  8. //---- range functions ---------------------------------------------------------
  9.  
  10. void CharacterRange(Text*, int at, int *start, int *end)
  11. {
  12.     *start= *end= at;    
  13. }
  14.  
  15. void WordRange(Text *t, int at, int *start, int *end)
  16. {
  17.     t->GetWordBoundaries(at, start, end);
  18. }
  19.  
  20. void ParagraphRange(Text *t, int at, int *start, int *end)
  21. {
  22.     t->GetParagraphBoundaries(at, start, end);
  23. }
  24.  
  25. //---- RangeSelector -----------------------------------------------------------
  26.  
  27. RangeSelector::RangeSelector(class TextView *t, TextRangeFP f)
  28. {
  29.     tv= t;
  30.     range= f;
  31. }
  32.  
  33. Command *RangeSelector::TrackMouse(TrackPhase tp, Point, Point np, Point)
  34. {
  35.     SelPoint nextp;
  36.     int start, end;
  37.     
  38.     np= np-tv->GetInnerOrigin();
  39.     
  40.     switch (tp) {
  41.     case eTrackPress:
  42.     tv->DoneTypeing();
  43.     tv->inTextSelector= TRUE;
  44.     tv->PointToPos(np, &nextp.viewp, &nextp.line, &nextp.ch);
  45.     range(tv->GetText(), nextp.ch, &start, &end);
  46.     DoPress(nextp, start, end);
  47.     break;
  48.     
  49.     case eTrackMove:
  50.     tv->PointToPos(np, &nextp.viewp, &nextp.line, &nextp.ch);
  51.     range(tv->GetText(), nextp.ch, &start, &end);
  52.     DoMove(nextp, start, end);
  53.     break;
  54.     
  55.     case eTrackRelease:
  56.     tv->inTextSelector= FALSE;
  57.     if ((tv->start.line == tv->end.line) && tv->Caret())
  58.         tv->InvalidateSelection();
  59.     tv->NormSelection();  
  60.     return gNoChanges;
  61.     }
  62.     return this;
  63. }
  64.  
  65. void RangeSelector::DoPress(SelPoint, int s, int e)
  66. {
  67.     tv->PrivSetSelection(s, e, FALSE);
  68.     startp= tv->start;
  69.     endp= tv->end;
  70. }
  71.  
  72. void RangeSelector::DoMove(SelPoint nextp, int s, int e)
  73. {
  74.     if (nextp.ch <= startp.ch) {
  75.     tv->CharToPos (nextp.ch= s, &nextp.line, &nextp.viewp);
  76.     if (!nextp.IsEqual(tv->start)) {
  77.         tv->InvalidateRange(nextp.line, nextp.viewp, tv->start.line, tv->start.viewp);
  78.         tv->start= nextp;
  79.     }
  80.     else if (tv->end.ch > endp.ch && !endp.IsEqual(tv->end)) {
  81.         tv->InvalidateRange(endp.line, endp.viewp, tv->end.line, tv->end.viewp);
  82.         tv->end= endp;
  83.     }            
  84.     } else {
  85.     tv->CharToPos(nextp.ch= e, &nextp.line, &nextp.viewp);
  86.     if (!nextp.IsEqual(tv->end)) {
  87.         tv->InvalidateRange(tv->end.line, tv->end.viewp, nextp.line, nextp.viewp);
  88.         tv->end= nextp;
  89.     } 
  90.     else if (tv->start.ch < startp.ch && !startp.IsEqual(tv->start)) {
  91.         tv->InvalidateRange(tv->start.line, tv->start.viewp, startp.line, startp.viewp);
  92.         tv->start= startp;
  93.     }
  94.     }
  95. }
  96.  
  97. //---- ExtendRangeSelector ----------------------------------------------------
  98.  
  99. ExtendRangeSelector::ExtendRangeSelector(TextView *tv, TextRangeFP rf) 
  100.                             : RangeSelector(tv, rf)
  101. {
  102.     swap= FALSE;
  103. }
  104.  
  105. void ExtendRangeSelector::DoPress(SelPoint nextp, int s, int e)
  106. {
  107.     SelPoint tmp;
  108.     
  109.     startp.ch= s;
  110.     endp.ch= e;
  111.     if (nextp.ch <= tv->start.ch) {     // extend at start 
  112.     tv->CharToPos(startp.ch, &startp.line, &startp.viewp);
  113.     tv->InvalidateRange(startp.line, startp.viewp, tv->start.line, tv->start.viewp);
  114.     tv->start= startp;
  115.     swap= TRUE;
  116.     } else {                            // extend at end
  117.     tv->CharToPos(endp.ch, &endp.line, &endp.viewp);
  118.     tv->InvalidateRange(tv->end.line, tv->end.viewp, endp.line, endp.viewp);
  119.     tv->end= endp;
  120.     }
  121.     startp= nextp;
  122. }
  123.  
  124. void ExtendRangeSelector::DoMove(SelPoint nextp, int s, int e)
  125. {
  126.     if (swap) {
  127.     swap= FALSE;
  128.     SwapSelPoints(tv->start, tv->end);
  129.     } 
  130.     if (nextp.ch < startp.ch)
  131.     tv->CharToPos (nextp.ch= s, &nextp.line, &nextp.viewp);
  132.     else
  133.     tv->CharToPos(nextp.ch= e, &nextp.line, &nextp.viewp);
  134.     
  135.     if (!nextp.IsEqual(tv->end)) {
  136.     tv->InvalidateRange(nextp.line, nextp.viewp, tv->end.line, tv->end.viewp);
  137.     tv->end= nextp;
  138.     } 
  139. }
  140.  
  141. //---- QuickPasteSelector ------------------------------------------------------
  142.  
  143. QuickPasteSelector::QuickPasteSelector(class TextView *tv, int f, int t)
  144.                                  : RangeSelector(tv)
  145. { 
  146.     from= f;
  147.     to= t;
  148. }
  149.  
  150. Command *QuickPasteSelector::TrackMouse(TrackPhase tp, Point ap, Point pp, Point np)
  151. {
  152.     Command *cmd= RangeSelector::TrackMouse(tp, ap, pp, np);
  153.     if (tp == eTrackRelease) {
  154.     if (tv->Caret()) {
  155.         tv->SetSelection(from, to);
  156.         return gNoChanges;
  157.     }
  158.     Text *t= tv->SelectionAsText();
  159.     tv->SetSelection(from, to);
  160.     return new PasteCommand(tv, t); 
  161.     }
  162.     return cmd;
  163. }
  164.  
  165. //---- CopyDragPasteSelector ---------------------------------------------------
  166.  
  167. CopyDragPasteSelector::CopyDragPasteSelector(class TextView *tvp, int f, int t)
  168. { 
  169.     from= f;
  170.     to= t;
  171.     tv= tvp;
  172. }
  173.  
  174. Command *CopyDragPasteSelector::TrackMouse(TrackPhase tp, Point, Point, Point)
  175. {
  176.     if (tp == eTrackRelease) {
  177.     int cfrom, cto;
  178.     tv->GetSelection(&cfrom, &cto);
  179.     tv->SetSelection(from, to, TRUE);
  180.     if (tv->Caret()) {
  181.         tv->SetSelection(cfrom, cto, TRUE);
  182.         return gNoChanges;
  183.     }
  184.     Text *t= tv->SelectionAsText();
  185.     tv->SetSelection(cfrom, cto, TRUE);
  186.     return new PasteCommand(tv, t); 
  187.     }
  188.     return this;
  189. }
  190.  
  191. void CopyDragPasteSelector::TrackFeedback(Point, Point np, bool on)
  192. {
  193.     if (on) {
  194.     Point p;
  195.     int line, ch;
  196.     tv->PointToPos(np, &p, &line, &ch);  
  197.     tv->SetSelection(ch, ch, TRUE);
  198.     }
  199. }
  200.  
  201. //----- TextCommand Methods ----------------------------------------------------
  202.  
  203. AbstractMetaImpl(TextCommand, (TP(tv), TP(oldText), T(oldStart), T(oldEnd), 0));
  204.  
  205. TextCommand::TextCommand (TextView *t, int cmdNo, char *cmdName, bool save)
  206.                             : Command(cmdNo, cmdName)
  207. {
  208.     tv= t;
  209.     tv->GetSelection(&oldStart, &oldEnd);
  210.     oldText= (Text*)tv->GetText()->New();
  211.     if (save && oldStart != oldEnd) // save old text
  212.     tv->Copy(oldText);
  213. }
  214.  
  215. TextCommand::~TextCommand ()
  216. {
  217.     SafeDelete(oldText);
  218. } 
  219.  
  220. void TextCommand::RestoreSelection ()
  221. {
  222.     tv->SetSelection(oldStart, oldEnd, FALSE);
  223. }
  224.  
  225. void TextCommand::RedoIt()
  226. {
  227.     RestoreSelection();
  228.     DoIt();
  229.     tv->RevealSelection();
  230. }
  231.  
  232. //----- CutCopyCommand Methods -------------------------------------------------
  233.  
  234. MetaImpl0(CutCopyCommand);
  235.  
  236. CutCopyCommand::CutCopyCommand(TextView *t, int cmdNo, char *cmdName) 
  237.                             : TextCommand(t, cmdNo, 0)
  238. { 
  239.     if (cmdName == 0) {
  240.     if (cmdNo == cCUT)
  241.         cmdName= "cut text";
  242.     else if (cmdNo == cCOPY)
  243.         cmdName= "copy text";
  244.     }
  245.     SetName(cmdName);
  246.     if (cmdNo == cCOPY)
  247.     ResetFlag(eCmdCausesChange);
  248. }
  249.  
  250. void CutCopyCommand::DoIt()
  251. {
  252.     if (GetId() == cCOPY)
  253.     return;
  254.     tv->Cut();
  255.     tv->RevealSelection();
  256. }  
  257.  
  258. void CutCopyCommand::UndoIt()
  259. {
  260.     Text *t= tv->GetText();    
  261.  
  262.     if (GetId() == cCUT) {
  263.     tv->SetSelection(oldStart, oldStart, FALSE);
  264.     if (oldText->Size()) 
  265.         tv->Paste(oldText);
  266.     RestoreSelection();
  267.     tv->RevealSelection();
  268.     }
  269. }
  270.  
  271. //----- Paste Command Methods --------------------------------------------------
  272.  
  273. MetaImpl(PasteCommand, (TP(pastetext), T(newStart), T(newEnd), 0));
  274.  
  275. PasteCommand::PasteCommand(TextView *t, Text *pt, int cmdNo, char *cmdName) 
  276.             : TextCommand(t, cmdNo, cmdName ? cmdName : "paste text")
  277. {
  278.     pastetext= pt;
  279. }
  280.  
  281. PasteCommand::~PasteCommand()
  282. {
  283.     SafeDelete(pastetext);
  284. }
  285.  
  286. void PasteCommand::DoIt()
  287. {
  288.     tv->Paste(pastetext);
  289.     tv->GetSelection(&newStart, &newEnd);
  290.     tv->RevealSelection();
  291. }  
  292.  
  293. void PasteCommand::UndoIt()
  294. {
  295.     tv->SetSelection(oldStart, newEnd, FALSE);
  296.     tv->Cut();
  297.     if (oldText->Size())
  298.     tv->Paste(oldText);
  299.     RestoreSelection();
  300.     tv->RevealSelection();
  301. }
  302.  
  303. //----- TypeInCommand Command Methods ------------------------------------------
  304.  
  305. MetaImpl(TypeingCommand, (TP(backspaceBuf), TP(newText), T(newStart), 0));
  306.  
  307. TypeingCommand::TypeingCommand(TextView *t, int cmdNo, char *cmdName) 
  308.                            : TextCommand(t, cmdNo, cmdName) 
  309. {
  310.     Text *txt= tv->GetText();
  311.     backspaceBuf= (Text*) txt->New();
  312.     newText= (Text*) txt->New();
  313.     newStart= oldStart;
  314.     completed= FALSE;
  315.     ResetFlag(eCmdDoDelete);
  316. }
  317.  
  318. TypeingCommand::~TypeingCommand()
  319. {
  320.     SafeDelete(backspaceBuf);
  321.     SafeDelete(newText);
  322. }
  323.  
  324. void TypeingCommand::Done(Command *newCmd)
  325. {
  326.     if (newCmd != this) {
  327.     if (newCmd == 0 || newCmd->GetId() != cTYPEING) {
  328.         SetFlag(eCmdDoDelete);
  329.         tv->TypeingDeleted();
  330.     } else
  331.         completed= TRUE;
  332.     }
  333. }
  334.  
  335. void TypeingCommand::UndoIt()
  336. {
  337.     Text *t= tv->GetText();
  338.     int firstNewChar;
  339.  
  340.     firstNewChar= min(oldStart - backspaceBuf->Size(),oldStart);
  341.     if (firstNewChar != newStart) {                     // save new text
  342.     t->Copy(newText, firstNewChar, newStart);         
  343.     tv->SetSelection(firstNewChar, newStart, TRUE);
  344.     tv->Cut();                                      // remove new text
  345.     } else
  346.     tv->SetSelection(firstNewChar, newStart, TRUE);
  347.     if (backspaceBuf->Size())                            
  348.     tv->Paste(backspaceBuf);                        // insert saved text
  349.     if (oldText->Size())
  350.     tv->Paste(oldText);
  351.     RestoreSelection();
  352.     tv->RevealSelection();
  353. }
  354.  
  355. void TypeingCommand::RedoIt()
  356. {
  357.     RestoreSelection();
  358.     tv->Cut();
  359.     if (backspaceBuf->Size()) {
  360.     tv->SetSelection(oldStart - backspaceBuf->Size(), oldStart, FALSE);
  361.     tv->Cut();        
  362.     }
  363.     if (newText->Size())
  364.     tv->Paste(newText);
  365.     tv->RevealSelection();
  366. }
  367.  
  368. void TypeingCommand::AddChar(int n)
  369. { 
  370.     newStart+= n; 
  371. }
  372.  
  373. void TypeingCommand::DelChar()
  374. {
  375.     Text *t= tv->GetText();
  376.  
  377.     if (newStart > 0)
  378.     newStart--;  
  379.     if (newStart < oldStart) 
  380.     if (oldStart - newStart > backspaceBuf->Size()) { // char already saved??
  381.         Text *tmp= t->Save(newStart, newStart+1);
  382.         backspaceBuf->Paste(tmp, 0, 0);
  383.         SafeDelete(tmp);
  384.     }
  385. }
  386.  
  387. //---- class ChangeStyle -------------------------------------------------------
  388.  
  389. MetaImpl(ChangeStyleCommand, (TP(newStyles), TP(oldStyles), TP(tvp), TE(mode), 0));
  390.  
  391. ChangeStyleCommand::ChangeStyleCommand(TextView *t, int cmdNo, char *cmdName, 
  392.        StChangeStyle m, StyleSpec ns) : TextCommand(t, cmdNo, cmdName, FALSE)
  393. {
  394.     if (!t->GetText()->IsKindOf(StyledText))
  395.     Error("ChangeStyleCommand::ChangeStyleCommand",
  396.                 "Apply ChangeStyleCommands only to StyledText");
  397.     newStyles= oldStyles= 0;
  398.     tvp= t; 
  399.     style= ns;
  400.     mode= m;
  401. }
  402.  
  403. void ChangeStyleCommand::DoIt()
  404. {
  405.     int from, to;
  406.     StyledText *sp= (StyledText*) tvp->GetText();
  407.  
  408.     tvp->GetSelection(&from, &to);
  409.     if (tvp->Caret())
  410.     sp->SetStyle (mode, from, to, style);
  411.     else {    
  412.     if (oldStyles == 0) 
  413.         oldStyles= new RunArray;
  414.     sp->CopyStyles (oldStyles, from, to);
  415.     sp->SetStyle (mode, from, to, style);
  416.     }
  417.     tvp->RevealSelection();
  418. }  
  419.  
  420. void ChangeStyleCommand::UndoIt()
  421. {
  422.     StyledText *sp= (StyledText*) tvp->GetText();
  423.  
  424.     if (oldStart == oldEnd)
  425.     sp->ResetCurrentStyle();
  426.     else {
  427.     if (newStyles == 0) {
  428.         newStyles= new RunArray;
  429.         sp->CopyStyles (newStyles, oldStart, oldEnd);
  430.     }
  431.     sp->ReplaceStyles (oldStyles, oldStart, oldEnd); 
  432.     }
  433.     RestoreSelection();
  434.     tvp->RevealSelection();
  435. }
  436.  
  437. void ChangeStyleCommand::RedoIt()
  438. {
  439.     StyledText *sp= (StyledText*) tvp->GetText();
  440.     if (oldStart == oldEnd)
  441.     sp->SetStyle(mode, oldStart, oldEnd, style);        
  442.     else
  443.     sp->ReplaceStyles(newStyles, oldStart, oldEnd); 
  444.     RestoreSelection();
  445.     tvp->RevealSelection();
  446. }
  447.